package com.carbon.carbonmanager.service;

import com.carbon.carbonmanager.mapper.UserMapper;
import com.carbon.carbonmanager.model.UserClassInfo;
import com.carbon.carbonmanager.model.UserInfo;
import com.carbon.carbonmanager.model.UserRegCodeInfo;
import com.carbon.carbonmanager.model.UserRoleInfo;
import com.carbon.carbonmanager.unit.*;
import org.apache.catalina.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;

@Service
public class UserService {
    @Autowired
    UserMapper userMapper;
    /**
     * 将用户注册邮箱和生成的注册码添加到数据库中
     * */
    public Boolean addRegCode(UserRegCodeInfo userRegCodeInfo){
        if(userMapper.addRegCode(userRegCodeInfo)>0){
            return true;
        }else {
            return false;
        }
    }

    /**
     * 删除已有邮箱的验证码，以便数据表中只保存唯一的验证码
     * */
    public Boolean delRegCode(UserRegCodeInfo userRegCodeInfo){
        if(userMapper.delRegCode(userRegCodeInfo)>0){
            return true;
        }else {
            return false;
        }
    }

    /**
     * 根据注册用户邮箱重置注册码
     * */
    public void resetRegCode(UserRegCodeInfo userRegCodeInfo){
        //删除清空注册码
        delRegCode(userRegCodeInfo);
        //再添加
        addRegCode(userRegCodeInfo);
    }


    /**
     * 注册用户验证邮箱与注册码是否匹配
     * */

    /**
     * 验证用户信息表中，注册用户的邮箱是否被使用过
     * */
    public Boolean validateEmailIsExisted(UserRegCodeInfo userRegCodeInfo){
        if(userMapper.validateEmailIsExisted(userRegCodeInfo)!=null){
            //已存在
            return true;
        }else {
            //未存在
            return false;
        }
    }

    /**
     * 验证用户名是否存在
     * */
    public Boolean validateUsernameIsExisted(UserInfo userInfo) {
        if (userMapper.validateUsernameIsExisted(userInfo) != null) {
            return true;
        } else{
            return false;
        }
     }

    /**
     * 注册用户验证邮箱与注册码是否匹配
     * */
    public Boolean validateRegCode(UserInfo userInfo){
        if(userMapper.validateRegCode(userInfo)!=null){
            //注册邮箱和验证码有效
            return true;
        }else {
            //验证码无效
            return false;
        }
    }

    /**
     * 注册成功后，清空当前用户生成的注册码
     * */
    public Boolean clearRegCode(UserInfo userInfo){
        if(userMapper.clearRegCode(userInfo)>0){
            return true;
        }else{
            return false;
        }
    }

    /**
     * 添加新用户
     * */
    public Boolean insertUser(UserInfo userInfo){
        //对用户密码进行加密
        userInfo.setUser_password(EncryptHelper.SHA(userInfo.getUser_password()));
        if(userMapper.insertUser(userInfo)>0){
            return true;
        }else {
            return false;
        }
    }

    /**
     * 登录成功后，修改登录时间
     * */
    public Boolean updateLoginTime(UserInfo userInfo){
        if(userMapper.updateLoginTime(userInfo)>0){
            return true;
        }else{
            return false;
        }
    }

     /**
      * 用户注册方法
      * */
     public Response RegUser(UserInfo userInfo){
         //第一步验证用户名是否已经存在
         if(validateUsernameIsExisted(userInfo)){
             //用户名已经使用
             return new Response(203,"当前用户名已使用",null);
         }else{
             //用户名未使用
             //判断注册邮箱和验证码是否有效
             if(validateRegCode(userInfo)){
                 //有效
                 //尝试将用户信息插入用户基础信息表
                 if(insertUser(userInfo)){
                     //添加成功
                     //清空注册码
                     clearRegCode(userInfo);
                     return new Response(200,"注册成功",null);
                 }else{
                     //添加失败
                     return new Response(203,"注册失败，请重试",null);
                 }
             }else{
                 //无效
                 return new Response(203,"注册码已过期",null);
             }
         }
     }

    /**
     * 用户登录功能
     * */
    public Response validateUser(UserInfo userInfo){
        //密码加密
        userInfo.setUser_password(EncryptHelper.SHA(userInfo.getUser_password()));
        UserInfo user = userMapper.validateUser(userInfo);
        if(user!=null){
            String token = TokenUtils.sign(userInfo);
            HashMap<String,Object> hs = new HashMap<>();
            hs.put("token",token);
            hs.put("user",user);
            //更新登录时间
            updateLoginTime(userInfo);
            return new Response(200,"登录成功",hs);
        }else{
            return new Response(203,"登录失败",null);
        }
    }

    /**
     * 查询所有用户信息
     * */
    public Response getAllUser(){
        return new Response(200,"查询成功",userMapper.getAllUser());
    }

    /**
     * 查询所有用户信息，分页数据
     * @return pagerData和pagerTotal
     * */
    public Response getAllUserPagerData(Pager pager){
        //当前pager对象只传递过来三个参数：username , currentPage,pageSize
        Integer startIndex = (pager.getCurrentPage()-1)*pager.getPageSize();
        pager.setStartIndex(startIndex);
        //计算分页查询数
        List<UserInfo> userdata = userMapper.getAllUserPagerData(pager);
        //装载数据
        PagerData pagerData = new PagerData();
        pagerData.setData(userdata);
        pagerData.setPageTotal(getAllUserTotal(pager));
        return new Response(200,"分页数据查询成功",pagerData);
    }

    /**
     * 查询所有用户信息，分页数据2
     * 计算总页码 前置条件
     * @return 返回数据总条数
     * */
    private Integer getAllUserPagerDataTotal(){
        return userMapper.getAllUserPagerDataTotal();
    }

    /**
     * 查询所有用户信息，分页数据3
     * 计算总页码
     * */
    public Integer getAllUserTotal(Pager pager){
        Integer dataTotals = getAllUserPagerDataTotal();
        Integer pageSize = pager.getPageSize();
        if(dataTotals%pageSize==0){
            //整除
            return dataTotals/pageSize;
        }else{
            //不整除
            return dataTotals/pageSize+1;
        }
    }

    /**
     * 使用登录验证数接口做权限操作验证
     *  验证管理员敏感操作
     * */
    public Boolean validateUserOperation(UserInfo userInfo){
        //新建权限比对字符串常量
        final String USER_ROLE_ADMIN = "admin";

        UserInfo user = userMapper.validateUserOperation(userInfo);
        String user_role = user.getUser_role();

        return USER_ROLE_ADMIN.equals(user_role);
    }

    /**
     * 获取用户角色列表
     * */
    public Response getUserRoleList(){
        List<UserRoleInfo> userRoleList = userMapper.getUserRoleList();
        if(userRoleList!=null){
            return new Response(200,"获取角色列表成功",userRoleList);
        }else{
            return new Response(203,"获取角色列表失败",null);
        }
    }

    /**
     * 获取用户企业类型
     * */
    public Response getUserClassList(){
        List<UserClassInfo> userClassList = userMapper.getUserClassList();
        if(userClassList!=null){
            return new Response(200,"获取角色列表成功",userClassList);
        }else{
            return new Response(203,"获取角色列表失败",null);
        }
    }


    /**
     * 根据用户id修改用户角色
     * */
    public Response updateUserRoleByUserId(UserInfo userInfo){
        System.out.println(userInfo.getUser_id());
        System.out.println(userInfo.getUr_id());
        System.out.println(userInfo.getUc_id());
        if(userMapper.updateUserRoleByUserId(userInfo)>0){
            //修改成功
            return new Response(200,"用户角色修改成功",null);
        }else{
            return new Response(203,"用户角色修改失败",null);
        }
    }
}
